<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <style>
        
    </style>
</head>
<body>
    
</body>
<script>

    // 为什么要将类中的方法再次抽象到规范身上

    // function Fn(b, c){
    //     this.brand = b;
    //     this.color = c;
    //     this.call = function(){
    //         console.log(this.color + "的" + this.brand + "可以打电话");
    //     }
    //     this.sendSMS = function(){
    //         console.log(this.color + "的" + this.brand + "可以发短信");
    //     }
    // }
    
    // const f1 = new Fn("小米","白色");
    // const f2 = new Fn("华为","红色");

    // console.log(f1);
    // console.log(f2);
    // console.log(f1 === f2);

    // f1.call();
    // f2.call();
    // f1.sendSMS();
    // f2.sendSMS();

    // console.log( f1.call === f2.call );






    // const arr1 = new Array(4,5,6,7);
    // const arr2 = new Array(4,5,6,7);

    // arr1.push("hello");
    // arr2.push("world");

    // console.log(arr1.push === arr2.push);

    // console.log(arr1);
    // console.log(arr2);

    // console.log(arr1 === arr2);







    // - 显式原型对象，用来存放类的规范
    //     - 语法：`构造函数.prototype`
    //     - 是一个对象类型的数据，可以存储多个方法
    // - 隐式原型对象，是一个指针，指向了显式原型对象
    //     - 语法：`实例.__proto__`
    //     - 规则：一般情况下，`__proto__`会被省略，会自动触发原型链的访问规则，读取到自身指向的显式原型对象的功能
    // - 原型链的规则：
    //     - 任何一个对象都具有隐式原型指针，在使用对象的属性或方法时，会先在对象自身查找，找到了就使用，并停止查找，找不到的话，顺着隐式原型指针逐层向上查找，直到找到Object.prototype都不存在，抛出undefined。

    function Fn(n, a){
        this.name = n;
        this.age = a;
    }
    Fn.prototype.show = function(){
        console.log(this.name);
    }
    // Fn.prototype.show();
    const f1 = new Fn("admin","17");
    const f2 = new Fn("root","17");
    console.log(f1);
    console.log(Fn.prototype === f1.__proto__);
    // f1.__proto__.show();
    f1.show();

    console.log( f1.show === f2.show );


    
</script>
</html>